package com.jomoo.css.common.core.util;

import cn.hutool.core.lang.Assert;
import com.jomoo.css.common.core.exception.BusinessException;
import lombok.experimental.UtilityClass;
import org.springframework.core.BridgeMethodResolver;
import org.springframework.core.DefaultParameterNameDiscoverer;
import org.springframework.core.MethodParameter;
import org.springframework.core.ParameterNameDiscoverer;
import org.springframework.core.annotation.AnnotatedElementUtils;
import org.springframework.core.annotation.SynthesizingMethodParameter;
import org.springframework.web.method.HandlerMethod;

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.List;

/**
 * 类工具类
 *
 * @author L.cm
 */
@UtilityClass
public class ClassUtils extends org.springframework.util.ClassUtils {
	private final ParameterNameDiscoverer PARAMETERNAMEDISCOVERER = new DefaultParameterNameDiscoverer();

	/**
	 * 获取方法参数信息
	 *
	 * @param constructor    构造器
	 * @param parameterIndex 参数序号
	 * @return {MethodParameter}
	 */
	public MethodParameter getMethodParameter(Constructor<?> constructor, int parameterIndex) {
		MethodParameter methodParameter = new SynthesizingMethodParameter(constructor, parameterIndex);
		methodParameter.initParameterNameDiscovery(PARAMETERNAMEDISCOVERER);
		return methodParameter;
	}

	/**
	 * 获取方法参数信息
	 *
	 * @param method         方法
	 * @param parameterIndex 参数序号
	 * @return {MethodParameter}
	 */
	public MethodParameter getMethodParameter(Method method, int parameterIndex) {
		MethodParameter methodParameter = new SynthesizingMethodParameter(method, parameterIndex);
		methodParameter.initParameterNameDiscovery(PARAMETERNAMEDISCOVERER);
		return methodParameter;
	}

	/**
	 * 获取Annotation
	 *
	 * @param method         Method
	 * @param annotationType 注解类
	 * @param <A>            泛型标记
	 * @return {Annotation}
	 */
	public <A extends Annotation> A getAnnotation(Method method, Class<A> annotationType) {
		Class<?> targetClass = method.getDeclaringClass();
		// The method may be on an interface, but we need attributes from the target class.
		// If the target class is null, the method will be unchanged.
		Method specificMethod = ClassUtils.getMostSpecificMethod(method, targetClass);
		// If we are dealing with method with generic parameters, find the original method.
		specificMethod = BridgeMethodResolver.findBridgedMethod(specificMethod);
		// 先找方法，再找方法上的类
		A annotation = AnnotatedElementUtils.findMergedAnnotation(specificMethod, annotationType);
		;
		if (null != annotation) {
			return annotation;
		}
		// 获取类上面的Annotation，可能包含组合注解，故采用spring的工具类
		return AnnotatedElementUtils.findMergedAnnotation(specificMethod.getDeclaringClass(), annotationType);
	}

	/**
	 * 获取Annotation
	 *
	 * @param handlerMethod  HandlerMethod
	 * @param annotationType 注解类
	 * @param <A>            泛型标记
	 * @return {Annotation}
	 */
	public <A extends Annotation> A getAnnotation(HandlerMethod handlerMethod, Class<A> annotationType) {
		// 先找方法，再找方法上的类
		A annotation = handlerMethod.getMethodAnnotation(annotationType);
		if (null != annotation) {
			return annotation;
		}
		// 获取类上面的Annotation，可能包含组合注解，故采用spring的工具类
		Class<?> beanType = handlerMethod.getBeanType();
		return AnnotatedElementUtils.findMergedAnnotation(beanType, annotationType);
	}

	/**
	 * 代理 class 的名称
	 */
	private static final List<String> PROXY_CLASS_NAMES = Arrays.asList("net.sf.cglib.proxy.Factory"
			// cglib
			, "org.springframework.cglib.proxy.Factory"
			, "javassist.util.proxy.ProxyObject"
			// javassist
			, "org.apache.ibatis.javassist.util.proxy.ProxyObject");

	/**
	 * 判断是否为代理对象
	 *
	 * @param clazz 传入 class 对象
	 * @return 如果对象class是代理 class，返回 true
	 */
	public static boolean isProxy(Class<?> clazz) {
		if (clazz != null) {
			for (Class<?> cls : clazz.getInterfaces()) {
				if (PROXY_CLASS_NAMES.contains(cls.getName())) {
					return true;
				}
			}
		}
		return false;
	}

	/**
	 * 获取当前对象的 class
	 *
	 * @param clazz 传入
	 * @return 如果是代理的class，返回父 class，否则返回自身
	 */
	public static Class<?> getUserClass(Class<?> clazz) {
		return isProxy(clazz) ? clazz.getSuperclass() : clazz;
	}

	/**
	 * 获取当前对象的class
	 *
	 * @param object 对象
	 * @return 返回对象的 user class
	 */
	public static Class<?> getUserClass(Object object) {
		Assert.notNull(object, "Error: Instance must not be null");
		return getUserClass(object.getClass());
	}

	/**
	 * 根据指定的 class ， 实例化一个对象，根据构造参数来实例化
	 * <p>
	 * 在 java9 及其之后的版本 Class.newInstance() 方法已被废弃
	 *
	 * @param clazz 需要实例化的对象
	 * @param <T>   类型，由输入类型决定
	 * @return 返回新的实例
	 */
	public static <T> T newInstance(Class<T> clazz) {
		try {
			Constructor<T> constructor = clazz.getDeclaredConstructor();
			constructor.setAccessible(true);
			return constructor.newInstance();
		} catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
			throw new BusinessException("实例化对象时出现错误,请尝试给 "+clazz.getName()+" 添加无参的构造方法", e );
		}
	}

	/**
	 * 请仅在确定类存在的情况下调用该方法
	 *
	 * @param name 类名称
	 * @return 返回转换后的 Class
	 */
	public static Class<?> toClassConfident(String name) {
		try {
			return Class.forName(name);
		} catch (ClassNotFoundException e) {
			throw new BusinessException("找不到指定的class！请仅在明确确定会有 class 的时候，调用该方法", e);
		}
	}

}
